package com.kawaiim.zhj.OutCard;

import java.util.Collections;
import java.util.List;

import com.kawaiim.zhj.entity.Card;
/*
单张：任意一张牌，如一张3

一对：任意两张点数相同的牌，如33

连牌（顺子）：任意三张以及以上点数相邻的牌：345  2345 JQKA

姐妹对（双顺）：任意三对以及以上点数相邻的牌：334455  223344

2
炸弹：任意三张点数相同的牌：333 555 888

闪电：任意四张点数相同的牌：3333 4444 9999

3
比较

    单张：3<4<……<K<A<2

    一对：33<44<……<KK<AA<22

    连牌比较最大张点数：234<456,3456<JQKA

    姐妹对比较最大对子：223344<556677



    炸弹可以大过单张，一对，连牌，姐妹对。
    氢弹可以大过所有牌（除了铲牌）
**/

/**
 * @author Administrator
 */
public  class  OutCardStyle {
    public  OutCardStyleEnum outCardStyleEnum;      //出牌形式
    public int firstCardSize;       //相同牌的第一张
    public int cardLength;          //出牌的数量

    //构造函数
    public OutCardStyle(OutCardStyleEnum outCardStyleEnum, int firstCardSize, int cardLength) {
        this.outCardStyleEnum = outCardStyleEnum;
        this.firstCardSize = firstCardSize;
        this.cardLength = cardLength;
    }
    private OutCardStyle() {
        outCardStyleEnum = OutCardStyleEnum.CANT_OUT;
        firstCardSize = 0;
        cardLength = 0;
    }

    //判断是不是对子，返回对子的第一张牌
    public static int isTwo(List<Card> cards) {
        //如果两张牌不相等不是
        if (cards.get(0).sameCardNum == 2) {
            return cards.get(0).cardSize;
        } else {
            return 0;
        }
    }

    //判断是不是炸弹，返回第一张牌
    public static int isBomb(List<Card> cards) {
        if (cards.get(0).sameCardNum == 3) {
            return cards.get(0).cardSize;
        } else {
            return 0;
        }
    }
    //判断是不是闪电，返回第一张牌
    public static int isLightning(List<Card> cards) {
        if (cards.get(0).sameCardNum == 4) {
            return cards.get(0).cardSize;
        } else {
            return 0;
        }
    }



    //判断是不是姐妹对，返回第一个对子的第一张牌(最小的)
    public static int isNextTwo(List<Card> cards) {
        //按牌相同的数量排序（从大到小）再按牌的大小排序（从大到小）
        Collections.sort(cards, Card.CompareModeCardNum);

        int length = cards.size();
        //连对至少3对，且连对最大不能是2，不是都是对子，不是连的
        if (length < 6 || length % 2 != 0 || cards.get(0).cardSize > 14
                || cards.get(0).sameCardNum != 2
                || cards.get(0).sameCardNum != cards.get(length - 1).sameCardNum
                || (cards.get(0).cardSize - cards.get(length - 1).cardSize + 1) * 2 != length) {
            return 0;
        }

        return cards.get(length - 1).cardSize;
    }

    //判断是不是顺子，返回顺子的第一张牌
    public static int isStraight(List<Card> cards) {
        //按牌相同的数量排序（从大到小）再按牌的大小排序（从大到小）
        Collections.sort(cards, Card.CompareModeCardNum);

        int length = cards.size();
        //顺子最少3张，顺子最大不能是2，不是都是单支，不是连的
        if (length < 3 || cards.get(0).cardSize > 14
                || cards.get(0).sameCardNum != 1
                || cards.get(0).sameCardNum != cards.get(length - 1).sameCardNum
                || cards.get(0).cardSize - cards.get(length - 1).cardSize + 1 != length) {
            return 0;
        }

        return cards.get(length - 1).cardSize;
    }

    //判断出牌的种类
    public static OutCardStyle judgeCardStyle(List<Card> cards){
        //0出错，1单支，2对子，3三不带，4三带二，5连对，6顺子，7飞机不带，8飞机带两对，9炸弹，10四大天王
        //0出错，1单支，2对子，3 炸弹 4连对，5顺子，6 闪电 7铲子

        OutCardStyle cardStyle = new OutCardStyle();
        if (cards == null || cards.size() == 0) {
            cardStyle.outCardStyleEnum = OutCardStyleEnum.CANT_OUT;
            return cardStyle;
        }

        //保存出的牌的长度
        cardStyle.cardLength = cards.size();
        //先根据牌的数量判断单支，对子
        switch (cards.size()) {
            case 1:
                cardStyle.outCardStyleEnum = OutCardStyleEnum.ONE;
                cardStyle.firstCardSize = cards.get(0).cardSize;
                return cardStyle;

            case 2:
                cardStyle.firstCardSize = isTwo(cards);
                if (cardStyle.firstCardSize > 0) {
                    cardStyle.outCardStyleEnum = OutCardStyleEnum.TWO;
                    return cardStyle;
                }
                break;
            case 3:
                cardStyle.firstCardSize = isBomb(cards);
                if (cardStyle.firstCardSize > 0) {
                    cardStyle.outCardStyleEnum = OutCardStyleEnum.BOMB;
                    return cardStyle;
                }
                break;
            case 4:
                cardStyle.firstCardSize = isLightning(cards);
                if (cardStyle.firstCardSize > 0) {
                    cardStyle.outCardStyleEnum = OutCardStyleEnum.LIGHTNING;
                    return cardStyle;
                }
                break;
            default:
                break;

        }

        //判断连对
        cardStyle.firstCardSize = isNextTwo(cards);
        if (cardStyle.firstCardSize > 0) {
            cardStyle.outCardStyleEnum = OutCardStyleEnum.NEXT_TWO;
            return cardStyle;
        }

        //判断顺子
        cardStyle.firstCardSize = isStraight(cards);
        if (cardStyle.firstCardSize > 0) {
            cardStyle.outCardStyleEnum = OutCardStyleEnum.STRAIGHT;
            return cardStyle;
        }
        return cardStyle;
    }
}
